import { checkAllCart, deleteCart, findCart, getNewCartGoods, insertCart, mergeCart, updateCart } from '@/api/cart'

// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  // 修改购物车函数
  mutations: {
    // 覆盖购物车数据
    setCartList (state, list) {
      state.list = list
    },
    // 删除购物车商品
    deleteCart (state, skuId) {
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },
    // 修改更新购物车商品
    // commit('updateCart',{skuId:'xxx', count:1 })
    updateCart (state, goods) {
      const obj = state.list.find(item => item.skuId === goods.skuId)
      if (!obj) return
      for (const key in goods) {
        // if(goods[key])  不够严谨，因为 isEffective 字段可能出现 false， false 值也需要更新
        // 严谨的判断写法
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          obj[key] = goods[key]
        }
      }
    },
    // 加入购物车
    insertCart (state, payload) {
      // 考虑两种情况：
      const index = state.list.findIndex(item => item.skuId === payload.skuId)
      //  情况1：没有添加过的就添加到列表前
      if (index === -1) {
        state.list.unshift(payload)
      } else {
        //  情况2：已经添加过的商品(skuid已存在)，是数量的累加
        state.list[index].count += payload.count
      }
    }
  },
  // 异步操作购物车的函数
  actions: {
    // 合并购物车
    async mergeLocalCart (store) {
      // 合并购物车
      const data = store.state.list.map(({ skuId, selected, count }) => ({ skuId, selected, count }))
      await mergeCart(data)
      // 获取购物车列表
      const { result } = await findCart()
      // console.log(result)
      store.commit('setCartList', result)
    },
    updateCartSku (store, { oldSkuId, newSkuObj }) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          // 1. 获取原先商品的数量
          // 2. 删除原先商品
          // 3. 获取修改的skuId 和 原先商品数量 做一个加入购物车操作
          // 4. 更新列表
          const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
          deleteCart([oldSkuId]).then(async () => {
            await insertCart({ skuId: newSkuObj.skuId, count: oldGoods.count })
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          // 1. 先查找出来商品对象
          const oldSkuObj = store.state.list.find(item => item.skuId === oldSkuId)
          // console.log({ oldSkuObj, newSkuObj })
          // console.log(oldSkuObj)
          // 2. 从列表中删除
          store.commit('deleteCart', oldSkuId)
          // 3. 获取数据并改名更新(因为商品详情页和购物车列表页后端返回的字段名不同)
          const { price: nowPrice, inventory: stock, oldPrice: price, skuId, attrsText } = newSkuObj
          // 4. 合并成完整的购物车商品对象
          store.commit('insertCart', { ...oldSkuObj, nowPrice, stock, price, skuId, attrsText })
          resolve('本地操作成功')
        }
      })
    },
    // 批量删除选中商品
    batchDeleteCart (store, isInvalid) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          // console.log(isInvalid)
          const ids = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          // console.log(ids)
          deleteCart(ids).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].forEach(item => {
            store.commit('deleteCart', item.skuId)
          })
          resolve('本地操作成功')
        }
      })
    },
    // 做有效商品的全选&反选
    checkAllCart (store, selected) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          const ids = store.getters.validList.map(item => item.skuId)
          checkAllCart({ selected, ids }).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          // console.log(selected)
          // console.log(store)
          store.getters.validList.forEach(item => {
            item.selected = selected
            store.commit('updateCart', item)
          })
          resolve('本地操作成功')
        }
      })
    },
    // 更新购物车商品
    updateCart (store, goods) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          updateCart(goods).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.commit('updateCart', goods)
          resolve('更新购物车商品')
        }
      })
    },
    // 删除购物车商品
    deleteCart (store, skuId) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          deleteCart([skuId]).then(() => {
            store.dispatch('findCartList')
          })
          resolve('线上接口')
        } else {
          // 情况2：未登录
          store.commit('deleteCart', skuId)
          resolve('删除成功,本地操作')
        }
      })
    },
    // 获取购物车列表
    findCartList (store) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          // resolve('线上接口')
          findCart().then(({ result }) => {
            store.commit('setCartList', result)
            resolve('获取购物车成功-线上')
          })
        } else {
          // 情况2：未登录 -  未登录也要同步最新商品信息(价格,库存...)
          store.state.list.forEach(async item => {
            // console.log(item.skuId)
            const { result } = await getNewCartGoods(item.skuId)
            // skuId 用于查找，result 是要更新的信息
            store.commit('updateCart', { ...result, skuId: item.skuId })
          })
          resolve('获取购物车成功-本地')
        }
      })
    },
    insertCart (store, payload) {
      return new Promise((resolve) => {
        // 情况1：有登录
        if (store.rootState.user.profile.token) {
          // 登录后 TODO ...
          insertCart(payload).then(() => {
            store.dispatch('findCartList')
          })
          // resolve('加入购物车成功-线上')
        } else {
          // 未登录
          store.commit('insertCart', payload)
          resolve('加入购物车成功-本地')
        }
      })
    }
  },
  // 相当于计算属性
  getters: {
    // 无效商品列表
    invalidList (state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 选中商品件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品总金额
    selectedAmount (state, getters) {
      return getters.selectedList.reduce((p, c) => p + (c.nowPrice * 100 * c.count), 0) / 100
    },
    // 有效商品列表
    validList (state) {
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 是否全选
    isCheckAll (state, getters) {
      return getters.selectedList.length !== 0 && getters.validList.length === getters.selectedList.length
    },
    // 有效商品件数
    validTotal (state, getters) {
      // let total = 0
      // getters.validList.forEach(item => {
      //   total += item.count
      // })
      // return total
      return getters.validList.reduce((total, item) => item.count + total, 0)
    },
    // 有效商品总金额
    validAmount (state, getters) {
      return getters.validList.reduce((total, item) => item.nowPrice * 100 * item.count + total, 0) / 100
    }
  }
}
